Page({

  /**
   * 页面的初始数据
   */
  data: {
    currentTab: 'all',
    loginToken: null, // 新增：存储登录Token
    userId: null, // 新增：存储用户ID
    apiBaseUrl: '', // 新增：API基础URL
    orders: [], // 修改：清空硬编码数据，改为空数组
    filteredOrders: [],
    countdownTimers: {},
    loading: false, // 新增：加载状态
    orderStats: { // 新增：订单统计
      total: 0,
      pending: 0,
      paid: 0,
      closed: 0
    }
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    console.log('=== Order页面加载开始 ===');
    
    // 获取用户认证信息和API配置
    this.getUserAuthInfo();
    
    let tab = options.type || 'all';
    this.setData({ currentTab: tab });
    
    // 等待认证信息获取完成后再加载订单数据
    this.loadOrdersAfterAuth();
  },

  // 新增：等待认证完成后加载订单数据
  loadOrdersAfterAuth() {
    // 检查认证信息是否已获取
    if (this.data.userId && this.data.loginToken) {
      this.loadUserOrders();
    } else {
      // 如果还没获取到，等待一下再试
      setTimeout(() => {
        this.loadOrdersAfterAuth();
      }, 500);
    }
  },

  // 新增：获取用户认证信息（用户ID和Token）
  getUserAuthInfo() {
    try {
      const storageUtil = require('../../../utils/storageUtil.js');
      const { http } = require('../../../utils/http.js');
      const userInfo = storageUtil.getUserInfo();
      const token = storageUtil.getToken();
      
      console.log('🔍 获取到的用户信息:', userInfo);
      console.log('🔍 获取到的Token:', token);
      
      if (userInfo && token) {
        console.log('✅ 成功获取用户认证信息');
        
        // 从用户信息中提取用户ID
        const userId = userInfo.userId || userInfo.id || userInfo.user_id;
        
        if (userId) {
          console.log('✅ 成功获取用户ID:', userId);
          
          // 获取API基础URL
          const apiBaseUrl = http.getBaseUrl ? http.getBaseUrl() : 'http://localhost:8080';
          
          this.setData({
            loginToken: token,
            userId: userId,
            apiBaseUrl: apiBaseUrl
          });
          
          console.log('✅ API配置:', { userId, apiBaseUrl });
          
          // 显示认证信息
          this.showAuthInfo(userId, token);
        } else {
          console.warn('⚠️ 用户信息中未找到用户ID字段');
          wx.showToast({
            title: '用户信息不完整',
            icon: 'none'
          });
        }
      } else if (!userInfo) {
        console.warn('⚠️ 未获取到用户信息，用户可能未登录');
        wx.showToast({
          title: '请先登录',
          icon: 'none'
        });
      } else if (!token) {
        console.warn('⚠️ 未获取到Token，用户可能未登录');
        wx.showToast({
          title: '请先登录',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('❌ 获取用户认证信息失败:', error);
      wx.showToast({
        title: '获取登录信息失败',
        icon: 'none'
      });
    }
  },

  // 新增：显示认证信息（用于调试）
  showAuthInfo(userId, token) {
    if (userId && token) {
      // 截取Token的前10位和后10位，中间用...代替，保护隐私
      const tokenLength = token.length;
      const displayToken = tokenLength > 20 
        ? `${token.substring(0, 10)}...${token.substring(tokenLength - 10)}`
        : token;
      
      console.log('🔑 认证信息:', {
        userId: userId,
        tokenLength: tokenLength,
        displayToken: displayToken,
        timestamp: new Date().toLocaleString()
      });
      
      // 页面Toast提示
      wx.showToast({
        title: `认证成功 - 用户ID: ${userId}`,
        icon: 'success',
        duration: 2000
      });
    }
  },

  // 新增：检查认证信息是否有效
  checkAuthValid() {
    const token = this.data.loginToken;
    const userId = this.data.userId;
    
    if (!token) {
      console.warn('⚠️ Token为空');
      return false;
    }
    
    if (!userId) {
      console.warn('⚠️ 用户ID为空');
      return false;
    }
    
    // 这里可以添加Token有效性检查逻辑
    // 比如检查Token长度、格式等
    if (token.length < 10) {
      console.warn('⚠️ Token长度异常');
      return false;
    }
    
    console.log('✅ 认证信息验证通过 - 用户ID:', userId);
    return true;
  },

  // 新增：刷新认证信息
  refreshAuth() {
    console.log('🔄 开始刷新认证信息...');
    this.getUserAuthInfo();
  },

  // 新增：显示当前认证状态
  showCurrentAuthStatus() {
    const token = this.data.loginToken;
    const userId = this.data.userId;
    
    console.log('📊 当前认证状态:', {
      hasToken: !!token,
      hasUserId: !!userId,
      tokenLength: token ? token.length : 0,
      userId: userId,
      timestamp: new Date().toLocaleString()
    });
    
    if (token && userId) {
      wx.showModal({
        title: '认证状态',
        content: `✅ 认证成功\n用户ID: ${userId}\nToken长度: ${token.length}位`,
        showCancel: false,
        confirmText: '确定'
      });
    } else {
      wx.showModal({
        title: '认证状态',
        content: '❌ 认证失败\n请检查登录状态',
        showCancel: false,
        confirmText: '确定'
      });
    }
  },

  // 新增：调用订单接口获取用户订单数据
  loadUserOrders() {
    const { userId, loginToken, apiBaseUrl } = this.data;
    
    if (!userId || !loginToken) {
      console.error('❌ 缺少用户ID或Token');
      return;
    }

    this.setData({ loading: true });
    
    console.log('🔄 开始加载用户订单数据...', { userId, apiBaseUrl });
    
    wx.request({
      url: `${apiBaseUrl}/points/info/userWith`,
      method: 'GET',
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${loginToken}`
      },
      data: {
        userId: userId,
        pageNum: 1,
        pageSize: 9999  // 设置一个很大的数值来获取全部数据
      },
      success: (res) => {
        console.log('📦 订单接口返回数据:', res);
        
        if (res.statusCode === 200 && res.data.code === 200) {
          // 获取全部数据，可能是rows或data字段
          const orderData = res.data.rows || res.data.data || [];
          console.log('✅ 成功获取订单数据:', orderData);
          console.log('📊 订单总数:', orderData.length);
          
          // 处理订单数据
          this.processOrderData(orderData);
        } else {
          console.error('❌ 订单接口返回错误:', res);
          wx.showToast({
            title: '获取订单数据失败',
            icon: 'none'
          });
        }
      },
      fail: (error) => {
        console.error('❌ 订单接口调用失败:', error);
        wx.showToast({
          title: '网络请求失败',
          icon: 'none'
        });
      },
      complete: () => {
        this.setData({ loading: false });
      }
    });
  },

  // 新增：后端状态到前端状态映射（兼容字符串与数字编码）
  mapBackendStatusToFrontend(backendStatus) {
    // 统一大写字符串
    const statusStr = typeof backendStatus === 'string' ? backendStatus.trim().toUpperCase() : backendStatus;
    // 数字/数字字符串兼容
    if (statusStr === 0 || statusStr === '0') return { key: 'pending', text: '待支付' };
    if (statusStr === 1 || statusStr === '1') return { key: 'paid', text: '已支付' };
    if (statusStr === 2 || statusStr === '2') return { key: 'close', text: '已关闭' };
    // 枚举兼容
    if (statusStr === 'PENDING') return { key: 'pending', text: '待支付' };
    if (statusStr === 'PAID') return { key: 'paid', text: '已支付' };
    if (statusStr === 'CLOSED' || statusStr === 'CLOSE') return { key: 'close', text: '已关闭' };
    // 回退
    return { key: 'pending', text: '待支付' };
  },

  // 新增：安全日期解析（兼容 2025-01-01 10:00:00 与 2025/01/01 10:00:00）
  parseDateSafe(dateTimeStr) {
    if (!dateTimeStr) return new Date(NaN);
    // 替换为斜杠以提高兼容性
    const normalized = dateTimeStr.replace(/-/g, '/');
    const d = new Date(normalized);
    return d;
  },

  // 新增：处理订单数据
  processOrderData(orderData) {
    try {
      // 过滤掉del不等于1的订单
      const validOrders = orderData.filter(order => {
        const del = order.del;
        if (del !== 1) {
          console.log('🚫 过滤掉删除的订单:', order.orderNo, 'del=', del);
          return false;
        }
        return true;
      });
      
      console.log('✅ 有效订单数量:', validOrders.length, '总订单数量:', orderData.length);
      
      // 转换订单数据格式
      const processedOrders = validOrders.map(order => {
        // 映射状态
        const mapped = this.mapBackendStatusToFrontend(order.status);
        const status = mapped.key;
        const statusText = mapped.text;
        
        // 计算倒计时（只有待支付订单需要）
        let remainingTime = '00:00';
        if (status === 'pending') {
          remainingTime = this.calculateRemainingTime(order.createTime);
        }
        
        return {
          id: order.id,
          userId: order.userId,
          questionBankId: order.questionBankId,
          orderNo: order.orderNo,
          amount: order.amount,
          points: order.points,
          status: status,
          statusText: statusText,
          createTime: order.createTime,
          payTime: order.payTime,
          closeTime: order.closeTime,
          remainingTime: remainingTime,
          // 保存完整的questionBank对象
          questionBank: order.questionBank,
          // 使用questionBank对象中的数据
          productName: order.questionBank ? order.questionBank.name : `题库${order.questionBankId}`,
          productType: order.questionBank ? order.questionBank.type : '题库练习',
          duration: '365天',
          price: Number(order.amount || 0).toFixed(2),
          // 使用questionBank中的url字段
          imageUrl: order.questionBank && order.questionBank.url ? order.questionBank.url : '/images/default-avatar.png',
          // 添加题库描述
          description: order.questionBank ? order.questionBank.description : '题库练习'
        };
      });
      
      console.log('🔄 处理后的订单数据:', processedOrders);
      
      // 更新页面数据
      this.setData({
        orders: processedOrders
      });
      
      // 重新过滤和初始化倒计时
      this.filterOrders(this.data.currentTab);
      this.initCountdowns();
      
      // 计算订单统计
      this.calculateOrderStats(processedOrders);
      
    } catch (error) {
      console.error('❌ 处理订单数据失败:', error);
    }
  },

  // 新增：计算剩余时间
  calculateRemainingTime(createTime) {
    try {
      const createDate = this.parseDateSafe(createTime);
      const expireDate = new Date(createDate.getTime() + 30 * 60 * 1000); // 30分钟
      const now = new Date();
      
      if (!(createDate instanceof Date) || isNaN(createDate)) {
        return '00:00';
      }
      
      if (now >= expireDate) {
        return '00:00'; // 已过期
      }
      
      const remainingMs = expireDate.getTime() - now.getTime();
      const remainingMinutes = Math.floor(remainingMs / (1000 * 60));
      const remainingSeconds = Math.floor((remainingMs % (1000 * 60)) / 1000);
      
      return `${remainingMinutes.toString().padStart(2, '0')}:${remainingSeconds.toString().padStart(2, '0')}`;
    } catch (error) {
      console.error('❌ 计算剩余时间失败:', error);
      return '00:00';
    }
  },

  // 新增：计算订单统计
  calculateOrderStats(orders) {
    const stats = {
      total: orders.length,
      pending: orders.filter(o => o.status === 'pending').length,
      paid: orders.filter(o => o.status === 'paid').length,
      closed: orders.filter(o => o.status === 'close').length
    };
    
    console.log('📊 订单统计:', stats);
    
    this.setData({
      orderStats: stats
    });
  },

  onTabChange(e) {
    const tab = e.currentTarget.dataset.type;
    this.setData({ currentTab: tab });
    this.filterOrders(tab);
    // 重新初始化倒计时
    this.initCountdowns();
  },

  filterOrders(tab) {
    if(tab==='all') {
      this.setData({ filteredOrders: this.data.orders });
    } else {
      this.setData({ filteredOrders: this.data.orders.filter(o=>o.status===tab) });
    }
    this.initCountdowns();
  },

  initCountdowns() {
    this.clearAllCountdowns();
    const countdownTimers = {};
    
    this.data.filteredOrders.forEach(order => {
      if (order.status === 'pending' && order.orderNo) {
        this.startCountdown(order, countdownTimers);
      }
    });
    
    this.setData({ countdownTimers });
  },

  startCountdown(order, countdownTimers) {
    const orderNo = order.orderNo;
    
    // 计算剩余时间
    const remainingSeconds = this.calculateRemainingSeconds(order.createTime);
    
    if (remainingSeconds > 0) {
      const timer = setInterval(() => {
        const currentRemaining = this.calculateRemainingSeconds(order.createTime);
        
        if (currentRemaining <= 0) {
          clearInterval(timer);
          this.handleOrderExpired(order);
        } else {
          this.updateOrderRemainingTime(orderNo, currentRemaining);
        }
      }, 1000);
      
      countdownTimers[orderNo] = timer;
      this.updateOrderRemainingTime(orderNo, remainingSeconds);
    } else {
      // 订单已过期，立即处理
      this.handleOrderExpired(order);
    }
  },

  // 新增：计算剩余秒数
  calculateRemainingSeconds(createTime) {
    try {
      const createDate = this.parseDateSafe(createTime);
      const expireDate = new Date(createDate.getTime() + 30 * 60 * 1000); // 30分钟
      const now = new Date();
      
      if (now >= expireDate) {
        return 0; // 已过期
      }
      
      return Math.floor((expireDate.getTime() - now.getTime()) / 1000);
    } catch (error) {
      console.error('❌ 计算剩余秒数失败:', error);
      return 0;
    }
  },

  updateOrderRemainingTime(orderNo, remainingSeconds) {
    const minutes = Math.floor(remainingSeconds / 60);
    const seconds = remainingSeconds % 60;
    const timeText = `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
    
    const orders = this.data.filteredOrders.map(order => {
      if (order.orderNo === orderNo) {
        return { ...order, remainingTime: timeText };
      }
      return order;
    });
    
    this.setData({ filteredOrders: orders });
  },

  handleOrderExpired(order) {
    console.log('⏰ 订单已过期:', order.orderNo);
    
    // 调用后端接口更新订单状态为已关闭
    this.updateOrderStatus(order.id, 'CLOSED');
    
    // 更新本地数据
    const orders = this.data.filteredOrders.map(o => {
      if (o.orderNo === order.orderNo) {
        return { 
          ...o, 
          status: 'close', 
          statusText: '已关闭',
          remainingTime: '00:00'
        };
      }
      return o;
    });
    
    this.setData({ filteredOrders: orders });
    
    wx.showToast({
      title: '订单已超时',
      icon: 'none'
    });
  },

  // 新增：删除订单，传入del=0
  deleteOrderById(orderId) {
    const { loginToken, apiBaseUrl } = this.data;
    
    if (!loginToken) {
      console.error('❌ 缺少Token');
      return;
    }
    
    console.log('🗑️ 删除订单:', { orderId });
    
    wx.showLoading({
      title: '删除中...'
    });
    
    wx.request({
      url: `${apiBaseUrl}/points/info`,
      method: 'PUT',
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${loginToken}`
      },
      data: {
        id: orderId,
        del: 0  // 删除标记
      },
      success: (res) => {
        console.log('📦 删除订单返回:', res);
        wx.hideLoading();
        
        if (res.statusCode === 200 && res.data.code === 200) {
          console.log('✅ 订单删除成功');
          wx.showToast({
            title: '订单已删除',
            icon: 'success',
            duration: 2000
          });
          
          // 重新加载订单数据
          setTimeout(() => {
            this.loadUserOrders();
          }, 1000);
        } else {
          console.error('❌ 删除订单失败:', res);
          wx.showToast({
            title: res.data.msg || '删除订单失败',
            icon: 'none',
            duration: 2000
          });
        }
      },
      fail: (error) => {
        console.error('❌ 删除订单接口调用失败:', error);
        wx.hideLoading();
        wx.showToast({
          title: '网络请求失败',
          icon: 'none',
          duration: 2000
        });
      }
    });
  },

  // 新增：取消订单，将状态更新为CLOSED
  updateOrderStatusToClosed(orderId) {
    const { loginToken, apiBaseUrl } = this.data;
    
    if (!loginToken) {
      console.error('❌ 缺少Token');
      return;
    }
    
    console.log('🔄 取消订单:', { orderId });
    
    wx.showLoading({
      title: '取消中...'
    });
    
    wx.request({
      url: `${apiBaseUrl}/points/info`,
      method: 'PUT',
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${loginToken}`
      },
      data: {
        id: orderId,
        status: 'CLOSED',
        closeTime: new Date().toISOString()
      },
      success: (res) => {
        console.log('📦 取消订单返回:', res);
        wx.hideLoading();
        
        if (res.statusCode === 200 && res.data.code === 200) {
          console.log('✅ 订单取消成功');
          wx.showToast({
            title: '订单已取消',
            icon: 'success',
            duration: 2000
          });
          
          // 重新加载订单数据
          setTimeout(() => {
            this.loadUserOrders();
          }, 1000);
        } else {
          console.error('❌ 取消订单失败:', res);
          wx.showToast({
            title: res.data.msg || '取消订单失败',
            icon: 'none',
            duration: 2000
          });
        }
      },
      fail: (error) => {
        console.error('❌ 取消订单接口调用失败:', error);
        wx.hideLoading();
        wx.showToast({
          title: '网络请求失败',
          icon: 'none',
          duration: 2000
        });
      }
    });
  },

  // 新增：调用后端接口更新订单状态
  updateOrderStatus(orderId, newStatus) {
    const { loginToken, apiBaseUrl } = this.data;
    
    if (!loginToken) {
      console.error('❌ 缺少Token');
      return;
    }
    
    console.log('🔄 更新订单状态:', { orderId, newStatus });
    
    wx.request({
      url: `${apiBaseUrl}/points/info`,
      method: 'PUT',
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${loginToken}`
      },
      data: {
        id: orderId,
        status: newStatus,
        closeTime: new Date().toISOString()
      },
      success: (res) => {
        console.log('📦 更新订单状态返回:', res);
        
        if (res.statusCode === 200 && res.data.code === 200) {
          console.log('✅ 订单状态更新成功');
          
          // 重新加载订单数据
          setTimeout(() => {
            this.loadUserOrders();
          }, 1000);
        } else {
          console.error('❌ 更新订单状态失败:', res);
        }
      },
      fail: (error) => {
        console.error('❌ 更新订单状态接口调用失败:', error);
      }
    });
  },

  clearAllCountdowns() {
    Object.values(this.data.countdownTimers).forEach(timer => {
      clearInterval(timer);
    });
    this.setData({ countdownTimers: {} });
  },

  onBack() {
    wx.navigateBack();
  },

  cancelOrder(e) {
    const orderId = e.currentTarget.dataset.orderId;
    wx.showModal({
      title: '确认取消',
      content: '确定要取消这个订单吗？',
      success: (res) => {
        if (res.confirm) {
          console.log('取消订单:', orderId);
          this.updateOrderStatusToClosed(orderId);
        }
      }
    });
  },

  continuePayment(e) {
    const orderId = e.currentTarget.dataset.orderId;
    console.log('继续支付订单:', orderId);
    wx.showToast({
      title: '跳转支付页面',
      icon: 'none'
    });
  },

  viewOrderDetail(e) {
    const orderId = e.currentTarget.dataset.orderId;
    console.log('查看订单详情:', orderId);
    wx.showToast({
      title: '查看订单详情',
      icon: 'none'
    });
  },

  startLearning(e) {
    const orderId = e.currentTarget.dataset.orderId;
    console.log('开始学习:', orderId);
    
    // 找到对应的订单数据
    const order = this.data.orders.find(o => o.id == orderId);
    if (!order) {
      console.error('未找到订单数据:', orderId);
      wx.showToast({
        title: '订单数据不存在',
        icon: 'none'
      });
      return;
    }
    
    // 获取题库信息
    const questionBank = order.questionBank;
    
    if (!questionBank) {
      console.error('未找到题库信息:', orderId);
      wx.showToast({
        title: '题库信息不完整，无法开始学习',
        icon: 'none',
        duration: 2000
      });
      return;
    }
    
    const questionBankId = order.questionBankId;
    const subjectId = questionBank.subjectId;
    
    if (!subjectId) {
      console.error('题库信息中缺少科目ID:', orderId);
      wx.showToast({
        title: '题库信息不完整，无法开始学习',
        icon: 'none',
        duration: 2000
      });
      return;
    }
    
    console.log('题库ID:', questionBankId, '科目ID:', subjectId);
    
    // 跳转到章节练习页面，传递题库ID和科目ID
    wx.navigateTo({
      url: `/index/pages/chapterPractice/chapterPractice?questionBankId=${questionBankId}&subjectId=${subjectId}`,
      success: () => {
        console.log('跳转到章节练习页面，题库ID:', questionBankId, '科目ID:', subjectId);
      },
      fail: (error) => {
        console.error('跳转失败:', error);
        wx.showToast({
          title: '页面跳转失败',
          icon: 'none'
        });
      }
    });
  },

  deleteOrder(e) {
    const orderId = e.currentTarget.dataset.orderId;
    wx.showModal({
      title: '确认删除',
      content: '删除后无法恢复，确定要删除吗？',
      success: (res) => {
        if (res.confirm) {
          console.log('删除订单:', orderId);
          this.deleteOrderById(orderId);
        }
      }
    });
  },

  reorder(e) {
    const orderId = e.currentTarget.dataset.orderId;
    console.log('重新购买:', orderId);
    
    // 找到对应的订单数据
    const order = this.data.orders.find(o => o.id == orderId);
    if (!order) {
      console.error('未找到订单数据:', orderId);
      wx.showToast({
        title: '订单数据不存在',
        icon: 'none'
      });
      return;
    }
    
    // 根据题库名称判断跳转页面
    const questionBankName = order.productName;
    console.log('题库名称:', questionBankName);
    
    if (questionBankName === '全站会员' || questionBankName === '题库会员') {
      // 跳转到会员详情页面
      wx.navigateTo({
        url: '/index/pages/memberDetail/memberDetail',
        success: () => {
          console.log('跳转到会员详情页面');
        },
        fail: (error) => {
          console.error('跳转失败:', error);
          wx.showToast({
            title: '页面跳转失败',
            icon: 'none'
          });
        }
      });
    } else {
      // 获取题库ID
      const questionBankId = order.questionBankId;
      console.log('题库ID:', questionBankId);
      
      // 跳转到题库商品页面，传递题库ID
      wx.navigateTo({
        url: `/index/pages/questionBankGoods/questionBankGoods?questionBankId=${questionBankId}`,
        success: () => {
          console.log('跳转到题库商品页面，题库ID:', questionBankId);
        },
        fail: (error) => {
          console.error('跳转失败:', error);
          wx.showToast({
            title: '页面跳转失败',
            icon: 'none'
          });
        }
      });
    }
  },

  goToHome() {
    wx.switchTab({
      url: '/pages/index/index'
    });
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {

  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {
    this.clearAllCountdowns();
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    console.log('🔄 用户下拉刷新');
    
    // 重新加载订单数据
    this.loadUserOrders();
    
    wx.showToast({
      title: '刷新成功',
      icon: 'success'
    });
    
    // 延迟停止下拉刷新，等待数据加载完成
    setTimeout(() => {
      wx.stopPullDownRefresh();
    }, 1000);
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {
    wx.showToast({
      title: '加载更多',
      icon: 'none'
    });
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {
    return {
      title: '我的订单',
      path: '/my/pages/Order/Order'
    };
  }
})
